package com.gosling.cloudspace.aop;

import com.gosling.cloudspace.common.annotation.HistoryRecord;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;

/**
 * 记录流水切面
 *
 * @author lihonglin
 * @date 2022/8/5 17:07
 */
@Aspect
@Component
public class IdentifyAspect {
    public static final Logger logger = LoggerFactory.getLogger(IdentifyAspect.class);
    @Autowired
    private PlatformTransactionManager transactionManager;
    @Autowired
    private TransactionDefinition transactionDefinition;
//    @Autowired
//    private RedisTemplate<String, String> redisTemplate;
//    @Value("${spring.profiles.active}")
//    private String active;

    @Pointcut("@annotation(com.gosling.cloudspace.common.annotation.HistoryRecord)")
    public void historyRecord() {
    }

    /****
     * 环绕通知切面
     *
     * @param aspectJoinPoint
     * @return
     */
    @Around(value = "historyRecord()")
    public Object historyRecord(ProceedingJoinPoint aspectJoinPoint) {
        logger.info(">>>>>>>>>>>>>前置<<<<<<<<<<<<<<<<<<");
        MethodSignature signature = (MethodSignature) aspectJoinPoint.getSignature();
        HistoryRecord annotation = signature.getMethod().getAnnotation(HistoryRecord.class);
        return null;
//        CommonInfo commonInfo = (CommonInfo) aspectJoinPoint.getArgs()[0];
//        logger.info("认证的参数:[{}]", JSON.toJSONString(commonInfo));
//        //一、内部必填字段不计入流水记账
//        try {
//            validateUtils.validate(commonInfo);
//        } catch (ValidateException e) {
//            logger.error("校验失败！", e.getMessage(), e);
//            throw new MobaoException(e.getMessage());
//        }
//        String source = annotation.source();
//        String preType = commonInfo.getPreServiceType();
//        //三、流水表存储每次来验证的记录，无论成功与否
//        IdentifyCallHistory history = new IdentifyCallHistory();
//        //雪花算法唯一订单号-一次流程订单唯一
//        String orderNo = commonInfo.getOrderNo();
//        LambdaQueryWrapper<IdentifyCallHistory> eq = new LambdaQueryWrapper<>();
//        eq.eq(IdentifyCallHistory::getOrderNo, orderNo);
//        history.setOrderNo(orderNo);
//        history.setIdentifyCode(annotation.code());
//        history.setProductName(annotation.product());
//        //四、加密字段存入elements
//        Field[] fields = commonInfo.getClass().getDeclaredFields();
//        Map modeField = modeField(commonInfo, fields);
//        String encriptMode = JSON.toJSONString(modeField);
//        //存字段值的md5 节省开销
//        String md5 = MD5.create().digestHex16(encriptMode).toLowerCase();
//        //如果是OCR则存图片的md5值区分更改与否
//        commonInfo.setImgBase64Md5(CommonConstants.CODE_722.equals(annotation.code()) ? md5 : null);
//        history.setElements(CommonConstants.CODE_722.equals(annotation.code()) ? md5 : encriptMode);
//        history.setIdentifyType(annotation.type());
//        history.setPreServiceType(preType);
//        history.setCustOrderNo(commonInfo.getCustOrderNo());
//        history.setChannel(source);
//        history.setIsFee(CommonConstants.IS_FEE_0);
//        //五、区分服务类型获取userId，以及商户简称，平台名称
//        putUserId(commonInfo, history, preType);
//        history.setCustNo(commonInfo.getCustPlatformNo());
//        //六、风控系统不控制-查自有库不限制
//        if (!SourceEnums.SELF.getCode().equals(source)) {
//            //相同前置系统编号 + 用户ID + 认证产品编号 + 通道编码 + 认证要素 + 成功状态
//            String msg = checkErrorCount(annotation, commonInfo, history, md5);
//            if (StringUtils.isNotBlank(msg)) {
//                logger.info(">>>>>>>>>>>>>前置次数已拦截<<<<<<<<<<<<<<<<<<");
//                return returnErrorMsg(annotation, msg);
//            }
//        }
//        //七、上送前校验
//        try {
//            //1.业务必填字段处理
//            fieldInfoCheck(commonInfo, fields);
//            //2.费率查询以及入账
//            if (!SourceEnums.SELF.getCode().equals(source)) {
//                List<IdentifyCallHistory> list = historyMapper.selectList(eq);
//                inAccountFee(history, list);
//            }
//        } catch (Exception e) {
//            String errorMsg = e.getMessage();
//            history.setRemarks(errorMsg);
//            //如果参数校验失败则状态为-未认证
//            history.setStatusCode(CommonConstants.true_2);
//            //通道类型则为空
//            history.setChannel(null);
//            logger.error(errorMsg);
//            logger.info(">>>>>>>>>>>>>前置业务参数异常拦截<<<<<<<<<<<<<<<<<<");
//            return returnErrorMsg(annotation, errorMsg);
//        } finally {
//            //根据订单号更新或新增
//            updateByOrderNo(history, eq);
//        }
//        logger.info(">>>>>>>>>>>>>后置<<<<<<<<<<<<<<<<<<");
//        //八、校验结果
//        BaseResult result = null;
//        String resultCode = null;
//        try {
//            //拿到返回参数
//            result = (BaseResult) aspectJoinPoint.proceed();
//            resultCode = CommonConstants.true_1.equals(result.getCode()) ? CommonConstants.true_1 : CommonConstants.true_0;
//            if (CommonConstants.CODE_722.equals(annotation.code()) && Objects.nonNull(result.getData())) {
//                //九、对OCR返回参数单独处理
//                history.setShortName(commonInfo.getCustNo());
//                putOcr(annotation, history, result, resultCode);
//            } else {
//                //十、正常返回参数
//                putResult(annotation, history, result, resultCode);
//            }
//        } catch (Throwable throwable) {
//            history.setRemarks("程序出错！");
//            history.setIsFee(CommonConstants.IS_FEE_0);
//            history.setStatusCode(CommonConstants.true_0);
//            logger.error("程序出错！{},{}", throwable.getMessage(), throwable);
//        } finally {
//            //十一、自有如果成功的就收费
//            if (SourceEnums.SELF.getCode().equals(source) && CommonConstants.true_1.equals(resultCode)) {
//                history.setIsFee(CommonConstants.IS_FEE_1);
//                try {
//                    //2.费率查询以及入账
//                    List<IdentifyCallHistory> list = historyMapper.selectList(eq);
//                    inAccountFee(history, list);
//                } catch (Exception e) {
//                    String errorMsg = e.getMessage();
//                    history.setRemarks(errorMsg);
//                    //如果参数校验失败则状态为-未认证
//                    history.setStatusCode(CommonConstants.true_2);
//                    //通道类型则为空
//                    history.setChannel(null);
//                    logger.error(errorMsg);
//                    logger.info(">>>>>>>>>>>>>前置业务参数异常拦截<<<<<<<<<<<<<<<<<<");
//                    result = returnErrorMsg(annotation, errorMsg);
//                }
//            }
//            //根据订单号更新或新增
//            updateByOrderNo(history, eq);
//        }
//        return result;
    }

//    private void inAccountFee(IdentifyCallHistory history, List<IdentifyCallHistory> list) throws Exception {
//        if (CollectionUtil.isNotEmpty(list)) {
//            String certAccStatus = list.get(0).getCertAccStatus();
//            if (!CommonConstants.ACC_STAT_1.equals(certAccStatus) && !CommonConstants.ACC_STAT_2.equals(certAccStatus)) {
//                //2.1.费率校验并回填-风控暂时不回填费率
//                checkFeeRate(history);
//                //2.2.调用记账入口将通道成功的商户入账
//                beforeInAccount(history);
//            }
//        } else {
//            //2.1.费率校验并回填-风控暂时不回填费率
//            checkFeeRate(history);
//            //2.2.调用记账入口将通道成功的商户入账
//            beforeInAccount(history);
//        }
//    }
//
//    /***
//     * 根据订单号更新或新增
//     *
//     * @param history
//     * @param eq
//     */
//    private void updateByOrderNo(IdentifyCallHistory history, LambdaQueryWrapper<IdentifyCallHistory> eq) {
//        int count = historyMapper.selectCount(eq);
//        if (count > 0) {
//            historyMapper.update(history, eq);
//        } else {
//            historyMapper.insert(history);
//        }
//    }
//
//    /***
//     * 调用入账-先入账后认证
//     *
//     * @param history
//     */
//    private void beforeInAccount(IdentifyCallHistory history) throws Exception {
//        //amt1+handlingFeeT1=orderAmt
//        //认证手续费
//        BigDecimal amtT1 = new BigDecimal(history.getCertFee()).setScale(2, BigDecimal.ROUND_UP);
//        BigDecimal zero = BigDecimal.ZERO.setScale(2, BigDecimal.ROUND_UP);
//        InAccountDTO inAccountDTO = new InAccountDTO();
//        inAccountDTO.setBrchNo(CommonConstants.DEFAULT_BRCHNO);
//        inAccountDTO.setT0t1(CommonConstants.T1);
//        inAccountDTO.setPayTime(new Date());
//        inAccountDTO.setPayType(history.getIdentifyCode());
//        inAccountDTO.setProductType(CommonConstants.PRODUCT_710);
//        inAccountDTO.setCcy(CommonConstants.CCY_CNY);
//        inAccountDTO.setAmtT0(zero);
//        inAccountDTO.setAmtT1(amtT1);
//        inAccountDTO.setHandlingFeeT0(zero);
//        inAccountDTO.setHandlingFeeT1(zero);
//        inAccountDTO.setOrderAmt(amtT1);
//        inAccountDTO.setOrderNo(history.getOrderNo());
//        inAccountDTO.setShortName(history.getShortName());
//        inAccountDTO.setChannel("0");
//        inAccountDTO.setPayChannel(getChannelDic(history));
//        inAccountDTO.setCustNo(history.getDeductFeeCustNo());
//        inAccountDTO.setTradeBrief(CommonConstants.TRADE_BRIEF);
//        inAccountDTO.setTradeKind(CommonConstants.TRADE_KIND);
//        ResultDTO resultDTO = null;
//        try {
//            logger.info(">>>>>>>>>>>>>调用记账入口开始<<<<<<<<<<<<<<<<<<");
//            logger.info("订单号:{}", history.getOrderNo());
//            logger.info("入参:{}", inAccountDTO);
//            resultDTO = tradeFeign.inAccount(inAccountDTO);
//            logger.info(">>>>>>>>>>>>>调用记账入口结束:{}<<<<<<<<<<<<<<<<<<");
//            logger.info("回参:{}", resultDTO);
//            if (!CommonConstants.true_1.equals(resultDTO.getRetCode())) {
//                throw new Exception(resultDTO.getRetMsg());
//            }
//            logger.info("入账成功！{}", resultDTO);
//            history.setCertAccStatus(CommonConstants.ACC_STAT_1);
//        } catch (Exception e) {
//            logger.error(e.getMessage(), e);
//            logger.error("入账失败！{},{}", resultDTO, e.getMessage());
//            history.setCertAccStatus(CommonConstants.ACC_STAT_0);
//            throw new Exception("入账失败:" + e.getMessage());
//        }
//
//    }
//
//    /***
//     * 上送通道标识
//     *
//     * @param history
//     * @return
//     */
//    private String getChannelDic(IdentifyCallHistory history) {
//        String channelDic = CommonConstants.SELF;
//        String channel = history.getChannel();
//        if (SourceEnums.SELF.getCode().equals(channel)) {
//            channelDic = CommonConstants.SELF;
//        } else if (SourceEnums.ANNLOP.getCode().equals(channel)) {
//            channelDic = CommonConstants.ANNLOP;
//        } else if (SourceEnums.SOOHAID.getCode().equals(channel)) {
//            channelDic = CommonConstants.SOOHAID;
//        } else if (SourceEnums.CHINA_DATA_PAY.getCode().equals(channel)) {
//            channelDic = CommonConstants.CHINA_DATA_PAY;
//        }
//        return channelDic;
//    }
//
//    /***
//     * 检验并回填费率
//     *
//     * @param history
//     * @throws Exception
//     */
//    private void checkFeeRate(IdentifyCallHistory history) throws Exception {
//        //获取商户对应的认证费率
//        String userId = history.getUserId();
//        String identifyCode = history.getIdentifyCode();
//        //先查询缓存中是否存在
//        StringBuilder key = new StringBuilder("maxwell-pre:cert-fee-rate:");
//        key.append(userId).append(":").append(identifyCode);
//        Map<String, Object> feeRate = null;
//        if (redisUtils.exists(key.toString())) {
//            feeRate = JSONObject.parseObject(redisUtils.get(key.toString()), Map.class);
//        } else {
//            HashMap<String, String> params = new HashMap<>();
//            params.put("customerPlatformNo", userId);
//            params.put("product", identifyCode);
//            ResultDTO merchCertFeeRate = maxwellService.merchCertFeeRate(params);
//            if (!CommonConstants.true_1.equals(merchCertFeeRate.getRetCode()) || Objects.isNull(merchCertFeeRate.getRetData())) {
//                String errorMsg = "未配置认证手续费:" + userId;
//                logger.error(">>>>>>>>>>>>>未配置认证手续费:{}<<<<<<<<<<<<<<<<<<", userId);
//                throw new Exception(errorMsg);
//            }
//            feeRate = (Map) merchCertFeeRate.getRetData();
//        }
//        //费率
//        history.setCertFee(feeRate.get("fixedAmount").toString());
//        //扣费商户号
//        history.setDeductFeeCustNo(feeRate.get("customerNo").toString());
//    }
//
//    /**
//     * 返回正常参数
//     *
//     * @param annotation
//     * @param history
//     * @param result
//     * @param resultCode
//     */
//    private void putResult(HistoryRecord annotation, IdentifyCallHistory history, BaseResult result, String resultCode) {
//        Object respData = result.get("respData");
//        specialfield(annotation, history, respData, result);
//        String returnMsg = result.getMsg();
//        history.setRespData(String.valueOf(respData));
//        history.setRemarks(returnMsg);
//        history.setStatusCode(resultCode);
//        Common common = new Common();
//        common.setCode(resultCode);
//        common.setMsg(returnMsg);
//        common.setSource(annotation.source());
//        result.clear();
//        result.put("source", annotation.source());
//        result.put(ResultEnum.DATA.code, common);
//        result.put(ResultEnum.MSG.code, returnMsg);
//        result.put(ResultEnum.CODE.code, resultCode);
//        result.put(ResultEnum.SERVICE_NAME.code, ResultEnum.MY_SERVICE_NAME.code);
//    }
//
//    /***
//     * OCR返回参数
//     *
//     * @param annotation
//     * @param history
//     * @param result
//     * @param resultCode
//     */
//    private void putOcr(HistoryRecord annotation, IdentifyCallHistory history, BaseResult result, String resultCode) {
//        Document domRoot = (Document) result.getData();
//        Element respData = domRoot.getRootElement().element("respData");
//        String domRespMsg = respData.elementText("respDesc");
//        String domResult = respData.elementText("result");
//        String returnMsg = result.getMsg();
//        history.setRespData(respData.asXML());
//        history.setRemarks(domRespMsg);
//        history.setStatusCode(resultCode);
//        history.setIsFee(CommonConstants.IS_FEE_1);
//        result.clear();
//        result.put("source", annotation.source());
//        result.put(ResultEnum.DATA.code, JSONObject.parseObject(domResult));
//        result.put(ResultEnum.MSG.code, returnMsg);
//        result.put(ResultEnum.CODE.code, resultCode);
//        result.put(ResultEnum.SERVICE_NAME.code, ResultEnum.MY_SERVICE_NAME.code);
//    }
//
//    /***
//     * 第三方独有特殊字段处理
//     * 收费标识和流水号
//     *
//     * @param annotation
//     * @param history
//     * @param respData
//     */
//    private void specialfield(HistoryRecord annotation, IdentifyCallHistory history, Object respData, BaseResult result) {
//        JSONObject jsonObject = null;
//        if (Objects.nonNull(respData)) {
//            jsonObject = JSON.parseObject(respData.toString());
//        }
//        if (SourceEnums.SOOHAID.getCode().equals(annotation.source())) {
//            history.setIsFee(Objects.nonNull(jsonObject) ? jsonObject.getString("fee") : CommonConstants.IS_FEE_2);
//        } else if (SourceEnums.ANNLOP.getCode().equals(annotation.source())) {
//            //安诺普返回的流水号，收费标识
//            history.setIsFee(Objects.nonNull(jsonObject) ? jsonObject.getString("pay") : CommonConstants.IS_FEE_2);
//            history.setResultOrderNo(Objects.nonNull(jsonObject) ? jsonObject.getString("resultflow") : null);
//        } else if (SourceEnums.SELF.getCode().equals(annotation.source())) {
//            //自有默认先不收费
//            history.setIsFee(CommonConstants.IS_FEE_0);
//        } else if (SourceEnums.CHINA_DATA_PAY.getCode().equals(annotation.source())) {
//            //数据宝-如果是3则说明异常-不收费，seqNo为序列号
//            history.setResultOrderNo(Objects.nonNull(jsonObject) ? jsonObject.getString("seqNo") : null);
//            history.setIsFee(Objects.isNull(result.get("state")) || CommonConstants.CHINA_DATA_PAY_3.equals(result.get("state")) ? CommonConstants.IS_FEE_0 : CommonConstants.IS_FEE_1);
//        }
//    }
//
//    /***
//     * 认证信息加密存储
//     *
//     * @param commonInfo
//     * @param fields
//     * @return
//     */
//    private Map modeField(CommonInfo commonInfo, Field[] fields) {
//        Map map = Maps.newHashMap();
//        for (Field field : fields) {
//            if (field.isAnnotationPresent(ElementsMode.class)) {
//                try {
//                    String name = field.getName();
//                    PropertyDescriptor pd = new PropertyDescriptor(name, commonInfo.getClass());
//                    map.put(name, pd.getReadMethod().invoke(commonInfo));
//                } catch (Exception ignored) {
//                }
//            }
//        }
//        return map;
//    }
//
//    /***
//     * 用户ID
//     * @param commonInfo
//     * @param history
//     * @param preType
//     * @return
//     */
//    private void putUserId(CommonInfo commonInfo, IdentifyCallHistory history, String preType) {
//        String userId = null;
//        if (CommonConstants.PRESERTP_GOSLING.equals(preType)) {
//            //前置服务为01-个人服务，用户ID为平台号或商户号
//            logger.info("前置服务类型:{},{}", "GOSLING", "个人服务");
//            history.setPreServiceName("个人服务GOSLING");
//            userId = commonInfo.getCustPlatformNo();
//            //获取商户简称
//            getName4platform(commonInfo, history);
//        } else if (CommonConstants.PRESERTP_LISHIZHEN.equals(preType)) {
//            //前置服务为02-商户中心，用户ID为商户号
//            logger.info("前置服务类型:{},{}", "LISHIZHEN", "商户中心");
//            history.setPreServiceName("商户中心LISHIZHEN");
//            userId = commonInfo.getCustPlatformNo();
//            //获取商户简称
//            getName4Maxwell(commonInfo, history);
//        } else if (CommonConstants.PRESERTP_MAXWELL.equals(preType)) {
//            //前置服务为04-运营系统，用户ID为商户号
//            logger.info("前置服务类型:{},{}", "MAXWELL", "运营系统");
//            history.setPreServiceName("运营系统MAXWELL");
//            userId = commonInfo.getCustPlatformNo();
//            //获取商户简称
//            getName4Maxwell(commonInfo, history);
//        } else if (CommonConstants.PRESERTP_TESLA.equals(preType)) {
//            //前置服务为03-风控系统，用户ID为空
//            logger.info("前置服务类型:{},{}", "TESLA", "风控系统");
//            history.setPreServiceName("风控系统TESLA");
//            userId = "test".equals(active) ? "199950002089" : "199950003715";
//            commonInfo.setCustPlatformNo(userId);
//        }
//        logger.info("userId:{}", userId);
//        history.setUserId(userId);
//    }
//
//    /***
//     * 相同前置系统编号 + 用户ID + 认证产品编号 + 通道编码 + 认证要素 + 成功状态
//     * 拦截主方法
//     *
//     * @param annotation
//     * @param commonInfo
//     * @return
//     */
//    private String checkErrorCount(HistoryRecord annotation, CommonInfo commonInfo, IdentifyCallHistory history, String md5) {
//        StringBuilder key = new StringBuilder("common:pre:identify_history:");
//        String userId = history.getUserId();
//        String preType = history.getPreServiceType();
//        String encriptMode = history.getElements();
//        String productCode = commonInfo.getProductCode();
//        String message = getMessage(commonInfo, productCode);
//        //前置服务类型+用户ID+第三方+银行卡/身份证+713/714+成功失败
//        key.append(preType).append(":");
//        key.append(userId).append(":");
//        key.append(annotation.source()).append(":");
//        key.append(message).append(":");
//        key.append(productCode).append(":");
//        key.append(md5).append(":");
//        key.append(CommonConstants.true_0);
//        StringBuilder key2 = new StringBuilder("common:pre:identify_history2:");
//        //前置服务类型+用户ID+第三方+银行卡/身份证+713/714+成功失败
//        key2.append(preType).append(":");
//        key2.append(userId).append(":");
//        key2.append(annotation.source()).append(":");
//        key2.append(message).append(":");
//        key2.append(productCode).append(":");
//        key2.append(CommonConstants.true_0);
//        StringBuilder key3 = new StringBuilder();
//        key3.append(key).append(":").append("errorMsg");
//        //当前时间到24：00之前的分钟数
//        long to24Min = getBetweenMinute();
//        //步骤一：若认证流水中存在相同认证要素、状态为失败、时间为当天，则无需在调用认证通道接口。直接返回：认证失败
//        if (redisTemplate.hasKey(key.toString())) {
//            long countKey = setKey2(key, to24Min);
//            String type = getBankOrId(productCode);
//            logger.error("该[{}]-相同认证要素今日认证失败次数已达[{}]次", type, countKey);
//            //获取原来的错误信息返回
//            String errorMsg = getErrorMsg(key3.toString());
//            if (StringUtils.isBlank(errorMsg)) {
//                List<IdentifyCallHistory> histories = getHistories(annotation, productCode, userId, preType, encriptMode, md5);
//                if (CollectionUtil.isNotEmpty(histories)) {
//                    errorMsg = "认证失败:[" + histories.get(0).getRemarks() + "]";
//                }
//            }
//            if (StringUtils.isBlank(errorMsg)) {
//                errorMsg = "认证失败:该[" + type + "]-相同认证要素今日认证失败次数已达[" + countKey + "]次";
//            }
//            redisTemplate.opsForValue().set(key3.toString(), errorMsg, to24Min, TimeUnit.MINUTES);
//            logger.error("errorMsg:[{}]", errorMsg);
//            return errorMsg;
//        } else {
//            //步骤二：如果redis不存在，则查数据库是否存在，存在则初始化次数为1
//            List<IdentifyCallHistory> histories = getHistories(annotation, productCode, userId, preType, encriptMode, md5);
//            if (CollectionUtil.isNotEmpty(histories)) {
//                String remarks = histories.get(0).getRemarks();
//                redisTemplate.opsForValue().set(key.toString(), "1", to24Min, TimeUnit.MINUTES);
//                if (redisTemplate.hasKey(key2.toString())) {
//                    long count = setKey2(key2, to24Min);
//                    logger.error("该[{}]今日认证失败次数已达[{}]次,失败原因[{}]", getBankOrId(productCode), count, remarks);
//                } else {
//                    redisTemplate.opsForValue().set(key2.toString(), "1", to24Min, TimeUnit.MINUTES);
//                    logger.error("该[{}]今日认证失败次数已达[1]次,失败原因[{}]", getBankOrId(productCode), remarks);
//                }
//                String errorMsg = "认证失败:[" + remarks + "]";
//                redisTemplate.opsForValue().set(key3.toString(), errorMsg, to24Min, TimeUnit.MINUTES);
//                return errorMsg;
//            }
//        }
//        //步骤三：如果身份证号存在，但不是相同参数，则+1
//        if (redisTemplate.hasKey(key2.toString())) {
//            long count = setKey2(key2, to24Min);
//            logger.error("该[{}]今日认证失败次数已达[{}]次", getBankOrId(productCode), count);
//            if (count >= 5) {
//                //如果次数到达5次或以上就返回-该银行卡号xxx今日认证失败次数已达5次。
//                return "该[" + getBankOrId(productCode) + "]今日认证失败次数已达[{" + count + "}]次";
//            }
//        } else {
//            //步骤四：如果redis不存在，则查数据库是否存在，存在则初始化次数为1
//            int historiesLikeCount = getHistoriesLike(annotation, productCode, userId, preType, md5, message);
//            if (historiesLikeCount > 0) {
//                //设置初始化值-1
//                redisTemplate.opsForValue().set(key2.toString(), "1", to24Min, TimeUnit.MINUTES);
//                logger.error("该[{}]今日认证失败次数已达[1]次", getBankOrId(productCode));
//            }
//        }
//        return null;
//    }
//
//    /***
//     * 获取失败信息
//     * @param key3
//     * @return
//     */
//    private String getErrorMsg(String key3) {
//        String errorMsg = null;
//        if (redisTemplate.hasKey(key3)) {
//            errorMsg = redisTemplate.opsForValue().get(key3);
//        }
//        return errorMsg;
//    }
//
//    private long setKey2(StringBuilder key, long betweenMinute) {
//        String redisJson = redisTemplate.opsForValue().get(key.toString());
//        long count = Long.parseLong(redisJson);
//        count++;
//        redisTemplate.opsForValue().set(key.toString(), String.valueOf(count), betweenMinute, TimeUnit.MINUTES);
//        return count;
//    }
//
//    public static void main(String[] args) {
//        System.out.println(DateUtil.parseDate(nDaysAgo(0)));
//        System.out.println(nDaysAgo(0));
////        System.out.println(DateUtil.parseDateTime(nDaysAgo(0)));
//    }
//
//    /***
//     * queryBuild
//     * @param annotation
//     * @param productCode
//     * @param userId
//     * @param preType
//     * @param encriptMode
//     * @return
//     */
//    private List<IdentifyCallHistory> getHistories(HistoryRecord annotation, String productCode, String userId, String preType, String encriptMode, String md5) {
//        QueryWrapper<IdentifyCallHistory> eq = new QueryWrapper<>();
//        eq.eq("pre_service_type", preType);
//        eq.eq("user_id", userId);
//        eq.eq("channel", annotation.source());
//        eq.eq("identify_code", productCode);
//        eq.eq("elements", CommonConstants.CODE_722.equals(productCode) ? md5 : encriptMode);
//        eq.eq("status_code", CommonConstants.true_0);
//        eq.ge("to_char(create_time,'YYYY-MM-DD')", nDaysAgo(0));
//        eq.isNotNull("create_time");
//        eq.orderByDesc("create_time");
//        return historyMapper.selectList(eq);
//    }
//
//    /***
//     * queryBuild
//     * @param annotation
//     * @param productCode
//     * @param userId
//     * @param preType
//     * @return
//     */
//    private int getHistoriesLike(HistoryRecord annotation, String productCode, String userId, String preType, String md5, String message) {
//        QueryWrapper<IdentifyCallHistory> eq = new QueryWrapper<>();
//        eq.eq("pre_service_type", preType);
//        eq.eq("user_id", userId);
//        eq.eq("channel", annotation.source());
//        eq.eq("identify_code", productCode);
//        eq.like("elements", CommonConstants.CODE_722.equals(productCode) ? md5 : message);
//        eq.eq("status_code", CommonConstants.true_0);
//        eq.ge("to_char(create_time,'YYYY-MM-DD')", nDaysAgo(0));
//        eq.isNotNull("create_time");
//        eq.orderByDesc("create_time");
//        return historyMapper.selectCount(eq);
//    }
//
//    /***
//     * 返回参数组装
//     *
//     * @param annotation
//     * @param errorMsg
//     * @return
//     */
//    private BaseResult returnErrorMsg(HistoryRecord annotation, String errorMsg) {
//        BaseResult result = BaseResult.error(errorMsg);
//        Common common = new Common();
//        common.setCode(CommonConstants.true_0);
//        common.setMsg(errorMsg);
//        common.setSource(annotation.source());
//        result.put("source", annotation.source());
//        result.put(ResultEnum.DATA.code, common);
//        return result;
//    }
//
//    private String getMessage(CommonInfo commonInfo, String productCode) {
//        String message = null;
//        switch (productCode) {
//            case CommonConstants.CODE_713:
//                message = commonInfo.getBankCard();
//                break;
//            case CommonConstants.CODE_712:
//                message = commonInfo.getBankCard();
//                break;
//            case CommonConstants.CODE_714:
//                message = commonInfo.getBankCard();
//                break;
//            case CommonConstants.CODE_716:
//                message = commonInfo.getIdCard();
//                break;
//            case CommonConstants.CODE_721:
//                message = commonInfo.getMobile();
//                break;
//            case CommonConstants.CODE_722:
//                message = commonInfo.getCustNo();
//                break;
//            default:
//                break;
//        }
//        return message;
//    }
//
//    private String getBankOrId(String productCode) {
//        String message = null;
//        switch (productCode) {
//            case CommonConstants.CODE_713:
//                message = "银行卡";
//                break;
//            case CommonConstants.CODE_712:
//                message = "银行卡";
//                break;
//            case CommonConstants.CODE_714:
//                message = "银行卡";
//                break;
//            case CommonConstants.CODE_716:
//                message = "身份证";
//                break;
//            case CommonConstants.CODE_721:
//                message = "手机号";
//                break;
//            case CommonConstants.CODE_722:
//                message = "OCR-跨境";
//                break;
//            default:
//                break;
//        }
//        return message;
//    }
//
//    /***
//     * 字段进行格式校验
//     * @param commonInfo
//     * @param fields
//     * @throws Exception
//     */
//    private void fieldInfoCheck(CommonInfo commonInfo, Field[] fields) throws Exception {
//        String productCode = commonInfo.getProductCode();
//        for (Field field : fields) {
//            if (field.isAnnotationPresent(CommonNotNull.class)) {
//                String name = field.getName();
//                Object invoke = null;
//                try {
//                    PropertyDescriptor pd = new PropertyDescriptor(name, commonInfo.getClass());
//                    invoke = pd.getReadMethod().invoke(commonInfo);
//                } catch (IntrospectionException | IllegalAccessException | InvocationTargetException e) {
//                    e.printStackTrace();
//                }
//                validate(productCode, field, name, invoke);
//            }
//        }
//    }
//
//    private void validate(String productCode, Field field, String name, Object invoke) throws Exception {
//        if (CommonConstants.CODE_713.equals(productCode)) {
//            if (CommonConstants.IDENTITY_713.contains(name)) {
//                check(field, name, invoke);
//            }
//        } else if (CommonConstants.CODE_714.equals(productCode)) {
//            if (CommonConstants.IDENTITY_714.contains(name)) {
//                check(field, name, invoke);
//            }
//        } else if (CommonConstants.CODE_716.equals(productCode)) {
//            if (CommonConstants.IDENTITY_716.contains(name)) {
//                check(field, name, invoke);
//            }
//        } else if (CommonConstants.CODE_721.equals(productCode)) {
//            if (CommonConstants.IDENTITY_721.contains(name)) {
//                check(field, name, invoke);
//            }
//        } else if (CommonConstants.CODE_722.equals(productCode)) {
//            if (CommonConstants.IDENTITY_722.contains(name)) {
//                check(field, name, invoke);
//            }
//        } else if (CommonConstants.CODE_712.equals(productCode)) {
//            if (CommonConstants.IDENTITY_712.contains(name)) {
//                check(field, name, invoke);
//            }
//        }
//    }
//
//    private void check(Field field, String name, Object invoke) throws Exception {
//        if (Objects.isNull(invoke)) {
//            CommonNotNull commonNotNull = field.getAnnotation(CommonNotNull.class);
//            throw new Exception(commonNotNull.message());
//        } else {
//            isPhoneAndIdCardAndBankCard(name, invoke);
//        }
//    }
//
//    private void isPhoneAndIdCardAndBankCard(String name, Object invoke) throws Exception {
//        String value = invoke.toString();
//        if (name.equals(CommonConstants.IDENTITY_MOBILE)) {
//            //验证是否为座机号码+手机号码(CharUtil中国)+400+800电话+手机号号码(香港)
//            if (!PhoneUtil.isPhone(SenseFieldTool.decryptMode(value))) {
//                throw new Exception(CommonConstants.PARAMS_ERROR[0]);
//            }
//        } else if (name.equals(CommonConstants.IDENTITY_IDCARD)) {
//            //身份证号码校验，10，15，18位身份证号码
//            if (!IdcardUtil.isValidCard(SenseFieldTool.decryptMode(value))) {
//                throw new Exception(CommonConstants.PARAMS_ERROR[1]);
//            }
//        } else if (name.equals(CommonConstants.IDENTITY_BANKCARD)) {
//            //银行卡校验，通用算法校验
//            if (!BankCardUtil.checkBankCard(SenseFieldTool.decryptMode(value))) {
//                throw new Exception(CommonConstants.PARAMS_ERROR[2]);
//            }
//        }
//    }
//
//    /***
//     * 获取商户名称-Maxwell
//     * @param arg
//     * @param history
//     */
//    private void getName4Maxwell(CommonInfo arg, IdentifyCallHistory history) {
//        try {
//            String customerNo = arg.getCustPlatformNo();
//            String key = "maxwell-pre:cust-info:" + customerNo;
//            String redis4Maxwell = redisTemplate.opsForValue().get(key);
//            String shortName = "";
//            if (StringUtils.isNotBlank(redis4Maxwell)) {
//                JSONObject jsonObject = JSONObject.parseObject(redis4Maxwell);
//                shortName = jsonObject.getString("shortName");
//            } else {
//                BaseResult data = maxwellService.basics(customerNo);
//                if (Objects.nonNull(data) && Objects.nonNull(data.getData())) {
//                    Map dataMap = (Map) data.getData();
//                    if (CollectionUtil.isNotEmpty(dataMap)) {
//                        shortName = (String) dataMap.get("shortName");
//                    }
//                }
//            }
//            history.setShortName(StringUtils.isBlank(shortName) ? "获取商户简称失败" : shortName);
//        } catch (Exception e) {
//            history.setShortName("获取商户简称失败");
//        }
//    }
//
//    /***
//     * 获取平台号信息-平台信息
//     * @param arg
//     * @param history
//     */
//    private void getName4platform(CommonInfo arg, IdentifyCallHistory history) {
//        String custNo = arg.getCustNo();
//        if (StringUtils.isNotBlank(custNo)){
//            history.setShortName(custNo);
//        } else {
//            try {
//                String platformNo = arg.getCustPlatformNo();
//                String key = "maxwell-pre:platform-info:" + platformNo;
//                String redis4Platform = redisTemplate.opsForValue().get(key);
//                String platformName = "";
//                if (StringUtils.isNotBlank(redis4Platform)) {
//                    JSONObject jsonObject = JSONObject.parseObject(redis4Platform);
//                    platformName = jsonObject.getString("platformName");
//                } else {
//                    ResultDTO resultDTO = maxwellService.getPlatformInfoByPlatformNo(platformNo);
//                    if (Objects.nonNull(resultDTO) && Objects.nonNull(resultDTO.getRetData())) {
//                        Map platformInfo = (Map) resultDTO.getRetData();
//                        if (CollectionUtil.isNotEmpty(platformInfo)) {
//                            platformName = (String) platformInfo.get("platformName");
//                        }
//                    }
//                }
//                history.setShortName(StringUtils.isBlank(platformName) ? "摩宝自拓" : platformName);
//            } catch (Exception e) {
//                history.setShortName("摩宝自拓");
//            }
//        }
//    }
//
//    /***
//     * 获取当前时间到24:00之前的分钟数
//     * @return
//     */
//    private long getBetweenMinute() {
//        Calendar cal = Calendar.getInstance();
//        cal.add(Calendar.DAY_OF_YEAR, 1);
//        cal.set(Calendar.HOUR_OF_DAY, 0);
//        cal.set(Calendar.SECOND, 0);
//        cal.set(Calendar.MINUTE, 0);
//        cal.set(Calendar.MILLISECOND, 0);
//        return (cal.getTimeInMillis() - System.currentTimeMillis()) / 1000 / 60;
//    }
}
